package com.example.managemyself.util;

import android.content.Context;
import android.util.Log;

import com.example.managemyself.data.model.Task;
import com.example.managemyself.data.repository.TaskRepository;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * AI任务管理器
 * 通过自然语言处理用户的任务管理请求
 */
public class AITaskManager {
    
    private static final String TAG = "AITaskManager";
    
    private final TaskRepository taskRepository;
    private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
    
    public AITaskManager(Context context) {
        this.taskRepository = new TaskRepository((android.app.Application) context.getApplicationContext());
    }
    
    /**
     * 任务操作回调接口
     */
    public interface TaskOperationCallback {
        void onSuccess(String message);
        void onError(String error);
    }
    
    /**
     * 处理AI任务管理请求
     * @param userMessage 用户输入的自然语言
     * @param callback 操作结果回调
     */
    public void processTaskRequest(String userMessage, TaskOperationCallback callback) {
        // 首先让AI理解用户意图
        String aiPrompt = String.format(
            "请分析以下用户请求，判断用户想要进行什么任务操作，并以JSON格式返回结果：\n\n" +
            "用户请求：\"%s\"\n\n" +
            "请返回JSON格式，包含以下字段：\n" +
            "{\n" +
            "  \"action\": \"add/delete/update/query\",\n" +
            "  \"taskTitle\": \"任务标题\",\n" +
            "  \"taskType\": \"学习/健康/杂务\",\n" +
            "  \"taskDescription\": \"任务描述\",\n" +
            "  \"dueDate\": \"yyyy-MM-dd格式的截止日期，如果没有指定则为null\",\n" +
            "  \"priority\": \"高/中/低\",\n" +
            "  \"keywords\": [\"搜索关键词数组\"]\n" +
            "}\n\n" +
            "注意：\n" +
            "- 如果是查询操作，keywords字段包含搜索关键词\n" +
            "- 如果是删除操作，keywords字段包含要删除的任务关键词\n" +
            "- 如果用户没有明确指定某些字段，请设为合理的默认值\n" +
            "- 只返回JSON，不要其他解释文字",
            userMessage
        );
        
        DeepSeekHelper.getChatResponse(aiPrompt, new DeepSeekHelper.DeepSeekCallback() {
            @Override
            public void onResponse(String response) {
                try {
                    // 提取JSON部分
                    String jsonStr = extractJsonFromResponse(response);
                    JSONObject taskIntent = new JSONObject(jsonStr);
                    
                    String action = taskIntent.getString("action");
                    
                    switch (action.toLowerCase()) {
                        case "add":
                            addTask(taskIntent, callback);
                            break;
                        case "delete":
                            deleteTask(taskIntent, callback);
                            break;
                        case "update":
                            updateTask(taskIntent, callback);
                            break;
                        case "query":
                            queryTasks(taskIntent, callback);
                            break;
                        default:
                            callback.onError("抱歉，我没有理解您的请求。请尝试说：'添加任务'、'删除任务'、'查询任务'或'修改任务'");
                    }
                    
                } catch (JSONException e) {
                    Log.e(TAG, "解析AI响应失败", e);
                    // 如果JSON解析失败，尝试基于关键词的简单匹配
                    handleSimpleTextRequest(userMessage, callback);
                }
                    }
                    
                    @Override
                    public void onError(String error) {
                // AI请求失败时，使用简单的关键词匹配
                handleSimpleTextRequest(userMessage, callback);
            }
        });
    }
    
    /**
     * 从AI响应中提取JSON部分
     */
    private String extractJsonFromResponse(String response) {
        // 寻找JSON开始和结束位置
        int startIndex = response.indexOf("{");
        int endIndex = response.lastIndexOf("}");
        
        if (startIndex != -1 && endIndex != -1 && endIndex > startIndex) {
            return response.substring(startIndex, endIndex + 1);
        }
        
        return response; // 如果没找到，返回原始响应
    }
    
    /**
     * 简单的文本请求处理（备用方案）
     */
    private void handleSimpleTextRequest(String userMessage, TaskOperationCallback callback) {
        String message = userMessage.toLowerCase();
        
        if (message.contains("添加") || message.contains("创建") || message.contains("新建")) {
            // 简单的添加任务逻辑
            String taskTitle = extractTaskTitle(userMessage);
            if (taskTitle.isEmpty()) {
                callback.onError("请告诉我要添加什么任务，例如：'添加学习任务：复习英语'");
            return;
        }
        
                         Task task = new Task(taskTitle, "AI辅助创建的任务");
             task.setType("学习");
             task.setUrgency("中");
             task.setDueDate(new Date());
             taskRepository.insertTask(task);
             callback.onSuccess("已添加任务：" + taskTitle);
            
        } else if (message.contains("删除") || message.contains("移除")) {
            callback.onError("请具体说明要删除哪个任务，例如：'删除复习英语任务'");
            
        } else if (message.contains("查询") || message.contains("查看") || message.contains("搜索")) {
            callback.onSuccess("请在任务页面查看您的所有任务，或者告诉我具体要查找什么任务");
            
        } else {
            callback.onError("请明确说明您要进行的操作：添加任务、删除任务、查询任务或修改任务");
        }
    }
    
    /**
     * 添加任务
     */
    private void addTask(JSONObject taskIntent, TaskOperationCallback callback) {
        try {
            String title = taskIntent.optString("taskTitle", "新任务");
            String description = taskIntent.optString("taskDescription", "");
            String type = taskIntent.optString("taskType", "学习");
            String priority = taskIntent.optString("priority", "中");
            String dueDateStr = taskIntent.optString("dueDate", null);
            
            // 验证任务类型
            if (!isValidTaskType(type)) {
                type = "学习"; // 默认类型
            }
            
            // 验证优先级
            if (!isValidPriority(priority)) {
                priority = "中"; // 默认优先级
            }
            
            // 解析截止日期
            Date dueDate = new Date(); // 默认今天
            if (dueDateStr != null && !dueDateStr.equals("null")) {
                try {
                    dueDate = dateFormat.parse(dueDateStr);
                } catch (ParseException e) {
                    Log.w(TAG, "日期解析失败，使用默认日期", e);
                }
            }
            
                         Task task = new Task(title, description);
             task.setType(type);
             task.setUrgency(priority);
             task.setDueDate(dueDate);
             taskRepository.insertTask(task);
             
             callback.onSuccess(String.format("✅ 已成功添加任务：\n标题：%s\n类型：%s\n优先级：%s\n截止日期：%s", 
                title, type, priority, dateFormat.format(dueDate)));
                
            } catch (Exception e) {
            Log.e(TAG, "添加任务失败", e);
            callback.onError("添加任务时发生错误：" + e.getMessage());
        }
    }
    
    /**
     * 删除任务
     */
    private void deleteTask(JSONObject taskIntent, TaskOperationCallback callback) {
        try {
            JSONArray keywords = taskIntent.optJSONArray("keywords");
            if (keywords == null || keywords.length() == 0) {
                callback.onError("请指定要删除的任务关键词，例如：'删除英语学习任务'");
                return;
            }
            
            // 这里需要异步查询，简化处理
            callback.onSuccess("删除功能需要您在任务列表中手动删除，或者告诉我具体的任务标题");
            
        } catch (Exception e) {
            Log.e(TAG, "删除任务失败", e);
            callback.onError("删除任务时发生错误：" + e.getMessage());
        }
    }
    
    /**
     * 更新任务
     */
    private void updateTask(JSONObject taskIntent, TaskOperationCallback callback) {
        try {
            String title = taskIntent.optString("taskTitle", "");
            if (title.isEmpty()) {
                callback.onError("请指定要修改的任务标题");
                return;
            }
            
            callback.onSuccess("修改任务功能需要您在任务列表中手动编辑，或者先告诉我要修改哪个具体任务");
                
            } catch (Exception e) {
            Log.e(TAG, "更新任务失败", e);
            callback.onError("更新任务时发生错误：" + e.getMessage());
        }
    }
    
    /**
     * 查询任务
     */
    private void queryTasks(JSONObject taskIntent, TaskOperationCallback callback) {
        try {
            JSONArray keywords = taskIntent.optJSONArray("keywords");
            String taskType = taskIntent.optString("taskType", "");
            
            StringBuilder result = new StringBuilder("📋 任务查询结果：\n\n");
            
            if (!taskType.isEmpty() && isValidTaskType(taskType)) {
                result.append("🔍 查询类型：").append(taskType).append("任务\n");
            }
            
            if (keywords != null && keywords.length() > 0) {
                result.append("🔍 关键词：");
                for (int i = 0; i < keywords.length(); i++) {
                    result.append(keywords.optString(i));
                    if (i < keywords.length() - 1) {
                        result.append(", ");
                    }
                }
                result.append("\n");
            }
            
            result.append("\n请在任务页面查看详细的任务列表，或者告诉我您要查找的具体任务信息。");
            
            callback.onSuccess(result.toString());
            
        } catch (Exception e) {
            Log.e(TAG, "查询任务失败", e);
            callback.onError("查询任务时发生错误：" + e.getMessage());
        }
    }
    
    /**
     * 从文本中提取任务标题
     */
    private String extractTaskTitle(String text) {
        // 匹配模式：添加任务：标题 或 添加学习任务：标题
        Pattern pattern = Pattern.compile("添加(?:.*?任务)?[：:](.+)");
        Matcher matcher = pattern.matcher(text);
        
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        
        // 如果没有匹配到，返回去除关键词后的文本
        String cleaned = text.replaceAll("(添加|创建|新建|任务)", "").trim();
        return cleaned.length() > 0 ? cleaned : "";
    }
    
    /**
     * 验证任务类型是否有效
     */
    private boolean isValidTaskType(String type) {
        return "学习".equals(type) || "健康".equals(type) || "杂务".equals(type);
    }
    
    /**
     * 验证优先级是否有效
     */
    private boolean isValidPriority(String priority) {
        return "高".equals(priority) || "中".equals(priority) || "低".equals(priority);
    }
} 